struct HasDrop1;
struct HasDrop2;
impl Drop for HasDrop1 {
    fn drop(&mut self) {
        println!("Dropping HasDrop1!");
    }
}

impl Drop for HasDrop2 {
    fn drop(&mut self) {
        println!("Dropping HasDrop2!");
    }
}

struct HasTwoDrops {
    one: HasDrop1,
    two: HasDrop2,
}
impl Drop for HasTwoDrops {
    fn drop(&mut self) {
        println!("Dropping HasTwoDrops!");
    }
}

struct Foo;
impl Drop for Foo {
    fn drop(&mut self) {
        println!("Dropping Foo!")
    }
}
#[test]
fn test_drop() {
    let _x = HasTwoDrops {
        two: HasDrop2,
        one: HasDrop1,
    };
    let _foo = Foo;
    println!("Running!");
}
//========Drop 
//Drop特征中的 drop 方法借用了目标的可变引用
//结构体中每个字段都有自己的 Drop

//========Drop 的顺序
//变量级别，按照逆序的方式
//结构体内部，按照顺序的方式

//Rust 自动为几乎所有类型都实现了 Drop 特征，因此就算你不手动为结构体实现 Drop，它依然会调用默认实现的 drop 函数，同时再调用每个字段的 drop 方法，最终打印出

//========手动回收
#[derive(Debug)]
struct Foo2;

impl Drop for Foo2 {
    fn drop(&mut self) {
        println!("Dropping Foo!")
    }
}

#[test]
fn test_drop_two() {
    let foo = Foo2;
    //手动回收
    std::mem::drop(foo);
    //println!("Running!:{:?}", foo);
}

//===========Drop 使用场景===========
//回收内存资源
//执行一些收尾工作

//=============互斥的 Copy 和 Drop==============
//无法为一个类型同时实现 Copy 和 Drop 特征
//因为实现了 Copy 特征的类型会被编译器隐式的复制，因此非常难以预测析构函数执行的时间和频率

